home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / netbon.zip / NETQUEW.INC < prev    next >
Text File  |  1992-10-02  |  25KB  |  940 lines
  1. {
  2.   NETQUEW.INC 1.1
  3. }
  4. function AbortServicingQueueJob(QueueID : LongInt; JobNum : Word) : Byte;
  5. type
  6.   TRequest    = record
  7.                   Len    : Word;
  8.                   SubF   : Byte;
  9.                   QID    : LongInt;
  10.                   JobN   : Word;
  11.                 end;
  12. var
  13.   Request    : ^TRequest;
  14.   Reply      : ^Word;
  15.   NovRegs    : Registers;
  16.   S, P : Pointer;
  17. begin
  18.   AbortServicingQueueJob := DPMIErrorVal;
  19.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  20.   Request := P;
  21.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  22.   Reply^ := $0000;
  23.  
  24.   with Request^ do begin
  25.     Len    := SizeOf(TRequest) - 2;
  26.     SubF   := SubFAbortServicingJob;
  27.     QID    := NetWareSwapLong(QueueID);
  28.     JobN   := Swap(JobNum);
  29.   end;
  30.  
  31.   with NovRegs do begin
  32.     AH := BinderyFunc;
  33.     DS := SegOfs(S).Segm;
  34.     SI := 0;
  35.     ES := SegOfs(S).Segm;
  36.     DI := SizeOf(TRequest);
  37.     WinIntr($21, NovRegs);
  38.     AbortServicingQueueJob := AL;
  39.   end;
  40.   FreeRealModeMem(P);
  41. end;
  42.  
  43. function AttachQueueServerToQueue(QueueID : LongInt) : Byte;
  44.  
  45. type
  46.   TRequest   = record
  47.                  Len    : Word;
  48.                  SubF   : Byte;
  49.                  QID    : LongInt;
  50.                end;
  51. var
  52.   Request    : ^TRequest;
  53.   Reply      : ^Word;
  54.   NovRegs    : Registers;
  55.   S, P : Pointer;
  56. begin
  57.   AttachQueueServerToQueue := DPMIErrorVal;
  58.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  59.   Request := P;
  60.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  61.   Reply^ := $0000;
  62.  
  63.   with Request^ do begin
  64.     Len    := SizeOf(TRequest) - 2;
  65.     SubF   := SubFAttachQueServ;
  66.     QID    := NetWareSwapLong(QueueID);
  67.   end;
  68.  
  69.   with NovRegs do begin
  70.     AH := BinderyFunc;
  71.     DS := SegOfs(S).Segm;
  72.     SI := 0;
  73.     ES := SegOfs(S).Segm;
  74.     DI := SizeOf(TRequest);
  75.     WinIntr($21, NovRegs);
  76.     AttachQueueServerToQueue := AL;
  77.   end;
  78.   FreeRealModeMem(P);
  79. end;
  80.  
  81.  
  82. function ChangeQueueJobEntry(QueueID : LongInt;
  83.                              var JobEntry : JobEntryType) : Byte;
  84.  
  85.  
  86. type
  87.   TRequest   = record
  88.                  Len    : Word;
  89.                  SubF   : Byte;
  90.                  QID    : LongInt;
  91.                  Job    : JobEntryType;
  92.                end;
  93. var
  94.   Request    : ^TRequest;
  95.   Reply      : ^Word;
  96.   NovRegs    : Registers;
  97.   S, P : Pointer;
  98. begin
  99.   ChangeQueueJobEntry := DPMIErrorVal;
  100.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  101.   Request := P;
  102.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  103.   Reply^ := $0000;
  104.  
  105.   with Request^ do begin
  106.     Len    := SizeOf(TRequest) - 2;
  107.     SubF   := SubFChangeJobEntry;
  108.     QID    := NetWareSwapLong(QueueID);
  109.     Job    := JobEntry;
  110.   end;
  111.  
  112.   with NovRegs do begin
  113.     AH := BinderyFunc;
  114.     DS := SegOfs(S).Segm;
  115.     SI := 0;
  116.     ES := SegOfs(S).Segm;
  117.     DI := SizeOf(TRequest);
  118.     WinIntr($21, NovRegs);
  119.     ChangeQueueJobEntry := AL;
  120.   end;
  121.   FreeRealModeMem(P);
  122. end;
  123.  
  124.  
  125. function ChangeQueueJobPosition(QueueID : LongInt; JobNumber : Word;
  126.                                 NewPosition : Byte) : Byte;
  127.  
  128. type
  129.   TRequest   = record
  130.                  Len    : Word;
  131.                  SubF   : Byte;
  132.                  QID    : LongInt;
  133.                  JobN   : Word;
  134.                  NewPos : Byte;
  135.                end;
  136. var
  137.   Request    : ^TRequest;
  138.   Reply      : ^Word;
  139.   NovRegs    : Registers;
  140.   S, P : Pointer;
  141. begin
  142.   ChangeQueueJobPosition := DPMIErrorVal;
  143.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  144.   Request := P;
  145.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  146.   Reply^ := $0000;
  147.  
  148.   with Request^ do begin
  149.     Len    := SizeOf(TRequest) - 2;
  150.     SubF   := SubFChangeJobPos;
  151.     QID    := NetWareSwapLong(QueueID);
  152.     JobN   := Swap(JobNumber);
  153.     NewPos := NewPosition;
  154.   end;
  155.  
  156.   with NovRegs do begin
  157.     AH := BinderyFunc;
  158.     DS := SegOfs(S).Segm;
  159.     SI := 0;
  160.     ES := SegOfs(S).Segm;
  161.     DI := SizeOf(TRequest);
  162.     WinIntr($21, NovRegs);
  163.     ChangeQueueJobPosition := AL;
  164.   end;
  165.   FreeRealModeMem(P);
  166. end;
  167.  
  168. function ChangeToClientRights(QueueID : LongInt; JobNumber : Word) : Byte;
  169. Type
  170.   TRequest   = record
  171.                  Len    : Word;
  172.                  SubF   : Byte;
  173.                  QID    : LongInt;
  174.                  JobN   : Word;
  175.                end;
  176. var
  177.   Request    : ^TRequest;
  178.   Reply      : ^Word;
  179.   NovRegs    : Registers;
  180.   S, P : Pointer;
  181. begin
  182.   ChangeToClientRights := DPMIErrorVal;
  183.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  184.   Request := P;
  185.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  186.   Reply^ := $0000;
  187.  
  188.   with Request^ do begin
  189.     Len    := SizeOf(TRequest) - SizeOf(Word);
  190.     SubF   := SubFChangeToClient;
  191.     QID    := NetWareSwapLong(QueueID);
  192.     JobN   := Swap(JobNumber);
  193.   end;
  194.  
  195.   with NovRegs do begin
  196.     AH := BinderyFunc;
  197.     DS := SegOfs(S).Segm;
  198.     SI := 0;
  199.     ES := SegOfs(S).Segm;
  200.     DI := SizeOf(TRequest);
  201.     WinIntr($21, NovRegs);
  202.     ChangeToClientRights := AL;
  203.   end;
  204.   FreeRealModeMem(P);
  205. end;
  206.  
  207. function CloseFileAndStartJob(QueueID : LongInt; JobNumber : Word) : Byte;
  208. type
  209.   TRequest   = record
  210.                  Len    : Word;
  211.                  SubF   : Byte;
  212.                  QID    : LongInt;
  213.                  JobN   : Word;
  214.                end;
  215. var
  216.   Request    : ^TRequest;
  217.   Reply      : ^Word;
  218.   NovRegs    : Registers;
  219.   S, P : Pointer;
  220. begin
  221.   CloseFileAndStartJob := DPMIErrorVal;
  222.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  223.   Request := P;
  224.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  225.   Reply^ := $0000;
  226.  
  227.   with Request^ do begin
  228.     Len    := SizeOf(TRequest) - SizeOf(Word);
  229.     SubF   := SubFCloseAndStart;
  230.     QID    := NetWareSwapLong(QueueID);
  231.     JobN   := Swap(JobNumber);
  232.   end;
  233.  
  234.   with NovRegs do begin
  235.     AH := BinderyFunc;
  236.     DS := SegOfs(S).Segm;
  237.     SI := 0;
  238.     ES := SegOfs(S).Segm;
  239.     DI := SizeOf(TRequest);
  240.     WinIntr($21, NovRegs);
  241.     CloseFileAndStartJob := AL;
  242.   end;
  243.   FreeRealModeMem(P);
  244. end;
  245.  
  246. function CreateQueue(QueType : Word; QueName : ObjNameStr;
  247.                      DirectoryHandle : Byte; PathName : QueuePathType;
  248.                      var QueueID : LongInt) : Byte;
  249. type
  250.   TRequest = record
  251.                Len        : Word;
  252.                SubF       : Byte;
  253.                ObjT       : Word;
  254.                Buf        : Array[1..170] of Byte;
  255.              end;
  256.   TReply   = record
  257.                Len        : Word;
  258.                QID        : LongInt;
  259.              end;
  260. var
  261.   Request       : ^TRequest;
  262.   Reply         : ^TReply;
  263.   NovRegs       : Registers;
  264.   Incr          : Word;
  265.   Index         : Byte;
  266.   S, P : Pointer;
  267. begin
  268.   CreateQueue := DPMIErrorVal;
  269.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  270.   Request := P;
  271.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  272.  
  273.   with Request^ do begin
  274.     SubF   := SubFCreateQue;
  275.     ObjT   := Swap(QueType);
  276.     Index  := 1;
  277.     Incr   := Succ(Length(QueName));
  278.     Move(QueName,Buf[Index],Incr);
  279.     Inc(Index,Incr);
  280.     Buf[Index] := DirectoryHandle;
  281.     Inc(Index);
  282.     Incr := Succ(Length(PathName));
  283.     Move(PathName,Buf[Index],Incr);
  284.     Inc(Index,Incr);
  285.     Len := Index + 2;
  286.   end;
  287.  
  288.   Reply^.Len := SizeOf(LongInt);
  289.  
  290.   with NovRegs do begin
  291.     AH := BinderyFunc;
  292.     DS := SegOfs(S).Segm;
  293.     SI := 0;
  294.     ES := SegOfs(S).Segm;
  295.     DI := SizeOf(TRequest);
  296.     WinIntr($21, NovRegs);
  297.     CreateQueue := AL;
  298.   end;
  299.   QueueID := NetWareSwapLong(Reply^.QID);
  300.   FreeRealModeMem(P);
  301. end;
  302.  
  303. function CreateQueueJobAndFile(QueueID : LongInt;
  304.                                JobEntry : JobEntryType;
  305.                                var ReplyEntry : JobEntryType) : Byte;
  306.  
  307. {page 12-23}
  308. type
  309.   TRequest = record
  310.                Len      : Word;
  311.                SubF     : Byte;
  312.                QID      : LongInt;
  313.                Entry    : JobEntryType;
  314.              end;
  315.   TReply   = record
  316.                Len      : Word;
  317.                REntry   : JobEntryType;
  318.              end;
  319. var
  320.   Request    : ^TRequest;
  321.   Reply      : ^TReply;
  322.   NovRegs    : Registers;
  323.   S, P : Pointer;
  324. begin
  325.   CreateQueueJobAndFile := DPMIErrorVal;
  326.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  327.   Request := P;
  328.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  329.  
  330.   with Request^ do begin
  331.     Len     := SizeOf(TRequest) - SizeOf(Word);
  332.     SubF    := SubFCreateJobAndFile;
  333.     QID     := NetWareSwapLong(QueueID);
  334.     Entry   := JobEntry;
  335.   end;
  336.   Reply^.Len := Ofs(Reply^.Rentry.TextJobDesc) - Ofs(Reply^.Rentry);
  337.  
  338.   with NovRegs do begin
  339.     AH := BinderyFunc;
  340.     DS := SegOfs(S).Segm;
  341.     SI := 0;
  342.     ES := SegOfs(S).Segm;
  343.     DI := SizeOf(TRequest);
  344.     WinIntr($21, NovRegs);
  345.     CreateQueueJobAndFile := AL;
  346.     if AL = 0 then
  347.       ReplyEntry := Reply^.REntry;
  348.   end;
  349.   FreeRealModeMem(P);
  350. end;
  351.  
  352.  
  353. function DestroyQueue(QueueID : LongInt) : Byte;
  354.  
  355. type
  356.   TRequest   = record
  357.                  Len    : Word;
  358.                  SubF   : Byte;
  359.                  QID    : LongInt;
  360.                end;
  361. var
  362.   Request    : ^TRequest;
  363.   Reply      : ^Word;
  364.   NovRegs    : Registers;
  365.   S, P : Pointer;
  366. begin
  367.   DestroyQueue := DPMIErrorVal;
  368.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  369.   Request := P;
  370.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  371.   Reply^ := $0000;
  372.  
  373.   with Request^ do begin
  374.     Len    := SizeOf(TRequest) - SizeOf(Word);
  375.     SubF   := SubFDestroyQue;
  376.     QID    := NetWareSwapLong(QueueID);
  377.   end;
  378.  
  379.   with NovRegs do begin
  380.     AH := BinderyFunc;
  381.     DS := SegOfs(S).Segm;
  382.     SI := 0;
  383.     ES := SegOfs(S).Segm;
  384.     DI := SizeOf(TRequest);
  385.     WinIntr($21, NovRegs);
  386.     DestroyQueue := AL;
  387.   end;
  388.   FreeRealModeMem(P);
  389. end;
  390.  
  391. function DetachQueueServerFromQueue(QueueID : LongInt) : Byte;
  392. type
  393.   TRequest   = record
  394.                  Len    : Word;
  395.                  SubF   : Byte;
  396.                  QID    : LongInt;
  397.                end;
  398. var
  399.   Request    : ^TRequest;
  400.   Reply      : ^Word;
  401.   NovRegs    : Registers;
  402.   S, P : Pointer;
  403. begin
  404.   DetachQueueServerFromQueue := DPMIErrorVal;
  405.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  406.   Request := P;
  407.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  408.   Reply^ := $0000;
  409.  
  410.   with Request^ do begin
  411.     Len    := SizeOf(TRequest) - SizeOf(Word);
  412.     SubF   := SubFDetachFromQue;
  413.     QID    := NetWareSwapLong(QueueID);
  414.   end;
  415.  
  416.   with NovRegs do begin
  417.     AH := BinderyFunc;
  418.     DS := SegOfs(S).Segm;
  419.     SI := 0;
  420.     ES := SegOfs(S).Segm;
  421.     DI := SizeOf(TRequest);
  422.     WinIntr($21, NovRegs);
  423.     DetachQueueServerFromQueue := AL;
  424.   end;
  425.   FreeRealModeMem(P);
  426. end;
  427.  
  428. function FinishServicingQueueJob(QueueID : LongInt; JobNumber : Word;
  429.                                  Charge : LongInt) : Byte;
  430. type
  431.   TRequest   = record
  432.                  Len    : Word;
  433.                  SubF   : Byte;
  434.                  QID    : LongInt;
  435.                  JobN   : Word;
  436.                  Chrg   : LongInt;
  437.                end;
  438. var
  439.   Request    : ^TRequest;
  440.   Reply      : ^Word;
  441.   NovRegs    : Registers;
  442.   S, P : Pointer;
  443. begin
  444.   FinishServicingQueueJob := DPMIErrorVal;
  445.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  446.   Request := P;
  447.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  448.   Reply^ := $0000;
  449.  
  450.   with Request^ do begin
  451.     Len    := SizeOf(TRequest) - SizeOf(Word);
  452.     SubF   := SubFFinishServicing;
  453.     QID    := NetWareSwapLong(QueueID);
  454.     JobN   := Swap(JobNumber);
  455.     Chrg   := Charge;
  456.   end;
  457.  
  458.   with NovRegs do begin
  459.     AH := BinderyFunc;
  460.     DS := SegOfs(S).Segm;
  461.     SI := 0;
  462.     ES := SegOfs(S).Segm;
  463.     DI := SizeOf(TRequest);
  464.     WinIntr($21, NovRegs);
  465.     FinishServicingQueueJob := AL;
  466.   end;
  467.   FreeRealModeMem(P);
  468. end;
  469.  
  470. function GetQueueJobList(QueueID : LongInt; var Jobs : QueueJobList) : Byte;
  471.  
  472. type
  473.   TRequest     = record
  474.                    Len    : Word;
  475.                    SubF   : Byte;
  476.                    ID     : LongInt;
  477.                  end;
  478.   TReply       = record
  479.                    Len    : Word;
  480.                    JobL   : QueueJobList;
  481.                    MaxJ   : Word;
  482.                  end;
  483. var
  484.   Request    : ^TRequest;
  485.   Reply      : ^TReply;
  486.   NovRegs    : Registers;
  487.   I          : Word;
  488.   S, P : Pointer;
  489. begin
  490.   GetQueueJobList := DPMIErrorVal;
  491.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  492.   Request := P;
  493.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  494.  
  495.   FillChar(Reply^,SizeOf(Reply^),Char(250));
  496.   Reply^.Len := SizeOf(TReply) - 2;
  497.   with Request^ do begin
  498.     Len     := SizeOf(TRequest) - 2;
  499.     SubF    := SubFGetJobList;
  500.     ID      := NetWareSwapLong(QueueID);
  501.   end;
  502.   with NovRegs do begin
  503.     AH := BinderyFunc;
  504.     DS := SegOfs(S).Segm;
  505.     SI := 0;
  506.     ES := SegOfs(S).Segm;
  507.     DI := SizeOf(TRequest);
  508.     WinIntr($21, NovRegs);
  509.     GetQueueJobList := AL;
  510.     if AL = 0 then
  511.       with Reply^ do begin
  512.         Jobs.NumJobs := Swap(JobL.NumJobs);
  513.         if Jobs.NumJobs > MaxQueueJobs then
  514.           Jobs.NumJobs := MaxQueueJobs;
  515.         for I := 1 to Jobs.NumJobs do
  516.           Jobs.JobList[I] := Swap(JobL.JobList[I]);
  517.       end;
  518.   end;
  519.   FreeRealModeMem(P);
  520. end;
  521.  
  522.  
  523. function GetQueueJobFileSize(QueueID : LongInt;
  524.                              JobNumber : Word;
  525.                              var SizeOfFile : LongInt) : Byte;
  526.  
  527. type
  528.   TRequest    = record
  529.                   Len    : Word;
  530.                   SubF   : Byte;
  531.                   ID     : LongInt;
  532.                   JobN   : Word;
  533.                 end;
  534.   TReply      = record
  535.                   Len      : Word;
  536.                   QID      : QueueJobList;
  537.                   JN       : Word;
  538.                   FSize    : LongInt; {h-l}
  539.                 end;
  540. var
  541.   Request     : ^TRequest;
  542.   Reply       : ^TReply;
  543.   NovRegs     : Registers;
  544.   I           : Word;
  545.   S, P : Pointer;
  546. begin
  547.   GetQueueJobFileSize := DPMIErrorVal;
  548.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  549.   Request := P;
  550.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  551.  
  552.   FillChar(Reply^,SizeOf(Reply^),0);
  553.   Reply^.Len := SizeOf(TReply) - 2;
  554.   with Request^ do begin
  555.     Len     := SizeOf(TRequest) - 2;
  556.     SubF    := SubFGetJobFileSize;
  557.     ID      :=  NetWareSwapLong(QueueID);
  558.     JobN    := JobNumber;
  559.   end;
  560.  
  561.   with NovRegs do begin
  562.     AH := BinderyFunc;
  563.     DS := SegOfs(S).Segm;
  564.     SI := 0;
  565.     ES := SegOfs(S).Segm;
  566.     DI := SizeOf(TRequest);
  567.     WinIntr($21, NovRegs);
  568.     GetQueueJobFileSize := AL;
  569.   end;
  570.  
  571.   SizeOfFile := NetWareSwapLong(Reply^.FSize);
  572.   FreeRealModeMem(P);
  573. end;
  574.  
  575. function ReadQueueCurrentStatus(QueueID : LongInt;
  576.                                 var QueueStatus : Byte;
  577.                                 var NumberOfJobs : Byte;
  578.                                 var NumberOfServers : Byte;
  579.                                 var ServerIDList : QueueServerIDList;
  580.                                 var StationList  : QueueStationList) : Byte;
  581.  
  582. type
  583.   TRequest    = record
  584.                   Len    : Word;
  585.                   SubF   : Byte;
  586.                   ID     : LongInt;
  587.                 end;
  588.   TReply      = record
  589.                   Len       : Word;
  590.                   ID        : LongInt;
  591.                   Status    : Byte;
  592.                   NumJobs   : Byte;
  593.                   NumServ   : Byte;
  594.                   ServerIDs : QueueServerIDList;
  595.                   Stations  : QueueStationList;
  596.                   MaxServs  : Byte;
  597.                 end;
  598. var
  599.   Request    : ^TRequest;
  600.   Reply      : ^TReply;
  601.   NovRegs    : Registers;
  602.   I          : Word;
  603.   S, P : Pointer;
  604. begin
  605.   ReadQueueCurrentStatus := DPMIErrorVal;
  606.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  607.   Request := P;
  608.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  609.  
  610.   FillChar(Reply^,SizeOf(Reply^),Char(25));
  611.   Reply^.Len := SizeOf(TReply) - 2;
  612.   with Request^ do begin
  613.     Len     := SizeOf(TRequest) - 2;
  614.     SubF    := SubFReadCurStatus;
  615.     ID      := NetWareSwapLong(QueueID);                   {!!.24}
  616.   end;
  617.   with NovRegs do begin
  618.     AH := BinderyFunc;
  619.     DS := SegOfs(S).Segm;
  620.     SI := 0;
  621.     ES := SegOfs(S).Segm;
  622.     DI := SizeOf(TRequest);
  623.     WinIntr($21, NovRegs);
  624.     ReadQueueCurrentStatus := AL;
  625.     if AL = 0 then
  626.       with Reply^ do begin
  627.         QueueStatus      := Status;
  628.         NumberOfJobs     := NumJobs;
  629.         NumberOfServers  := NumServ;
  630.         ServerIDList     := ServerIDs;
  631.         StationList      := Stations;
  632.       end;
  633.   end;
  634.   FreeRealModeMem(P);
  635. end;
  636.  
  637. function ReadJobEntry(QueueID : LongInt; JobNumber : Word;
  638.                       var JobEntry : JobEntryType) : Byte;
  639. type
  640.   TRequest    = record
  641.                   Len    : Word;
  642.                   SubF   : Byte;
  643.                   ID     : LongInt;
  644.                   Num    : Word;
  645.                 end;
  646.   TReply      = record
  647.                   Len       : Word;
  648.                   Entry     : JobEntryType;
  649.                 end;
  650. var
  651.   Request    : ^TRequest;
  652.   Reply      : ^TReply;
  653.   NovRegs    : Registers;
  654.   S, P : Pointer;
  655. begin
  656.   ReadJobEntry := DPMIErrorVal;
  657.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  658.   Request := P;
  659.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  660.  
  661.   with Request^ do begin
  662.     Len    := SizeOf(TRequest) - 2;
  663.     SubF   := SubFReadJobEntry;
  664.     ID     := NetWareSwapLong(QueueID);
  665.     Num    := Swap(JobNumber);
  666.   end;
  667.   Reply^.Len := SizeOf(TReply) - 2;
  668.   with NovRegs do begin
  669.     AH := BinderyFunc;
  670.     DS := SegOfs(S).Segm;
  671.     SI := 0;
  672.     ES := SegOfs(S).Segm;
  673.     DI := SizeOf(TRequest);
  674.     WinIntr($21, NovRegs);
  675.     ReadJobEntry := AL;
  676.     if AL = 0 then begin
  677. (*
  678.       Reply^.Entry.JobNumber := Swap(Reply^.Entry.JobNumber);
  679. *)
  680.       Reply^.Entry.JobType   := Swap(Reply^.Entry.JobType);
  681.       JobEntry := Reply^.Entry;
  682.     end;
  683.   end;
  684.   FreeRealModeMem(P);
  685. end;
  686.  
  687. function ReadQueueServerStatus(QueueID : LongInt; ServerID : LongInt;
  688.                                ServerStation : Byte) : Byte;
  689.  
  690. type
  691.   TRequest    = record
  692.                   Len    : Word;
  693.                   SubF   : Byte;
  694.                   ID     : LongInt; {h-l}
  695.                   ServID : LongInt; {h-l}
  696.                   ServSt : Byte;
  697.                 end;
  698.   TReply      = record
  699.                   Len : Word;
  700.                   ServStatusRec : ServerStatusRecord;
  701.                 end;
  702. var
  703.   Request    : ^TRequest;
  704.   Reply      : ^TReply;
  705.   NovRegs    : Registers;
  706.   S, P : Pointer;
  707. begin
  708.   ReadQueueServerStatus := DPMIErrorVal;
  709.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  710.   Request := P;
  711.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  712.  
  713.   Reply^.Len := SizeOf(TReply) - 2;
  714.   with Request^ do begin
  715.     Len    := SizeOf(TRequest) - 2;
  716.     SubF   := SubFReadQueServStatus;
  717.     ID     := NetWareSwapLong(QueueID);
  718.     ServID := ServerID;
  719.     ServSt := ServerStation;
  720.   end;
  721.   with NovRegs do begin
  722.     AH := BinderyFunc;
  723.     DS := SegOfs(S).Segm;
  724.     SI := 0;
  725.     ES := SegOfs(S).Segm;
  726.     DI := SizeOf(TRequest);
  727.     WinIntr($21, NovRegs);
  728.     ReadQueueServerStatus := AL;
  729.   end;
  730.   FreeRealModeMem(P);
  731. end;
  732.  
  733. function RemoveJobFromQueue(QueueID : LongInt; JobNumber : Word) : Byte;
  734. type
  735.   TRequest    = record
  736.                   Len    : Word;
  737.                   SubF   : Byte;
  738.                   ID     : LongInt;
  739.                   Num    : Word;
  740.                 end;
  741. var
  742.   Request    : ^TRequest;
  743.   Reply      : ^Word;
  744.   NovRegs    : Registers;
  745.   S, P : Pointer;
  746. begin
  747.   RemoveJobFromQueue := DPMIErrorVal;
  748.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  749.   Request := P;
  750.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  751.   Reply^ := $0000;
  752.  
  753.   with Request^ do begin
  754.     Len    := SizeOf(TRequest) - 2;
  755.     SubF   := SubFRemJobFromQue;
  756.     ID     := NetWareSwapLong(QueueID);
  757.     Num    := Swap(JobNumber);
  758.   end;
  759.   with NovRegs do begin
  760.     AH := BinderyFunc;
  761.     DS := SegOfs(S).Segm;
  762.     SI := 0;
  763.     ES := SegOfs(S).Segm;
  764.     DI := SizeOf(TRequest);
  765.     WinIntr($21, NovRegs);
  766.     RemoveJobFromQueue := AL;
  767.   end;
  768.   FreeRealModeMem(P);
  769. end;
  770.  
  771. function RestoreQueueServerRights : Byte;
  772. type
  773.   TRequest    = record
  774.                   Len  : Word;
  775.                   SubF : Byte;
  776.                 end;
  777. var
  778.   Request    : ^TRequest;
  779.   Reply      : ^Word;
  780.   NovRegs    : Registers;
  781.   S, P : Pointer;
  782. begin
  783.   RestoreQueueServerRights := DPMIErrorVal;
  784.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  785.   Request := P;
  786.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  787.   Reply^ := $0000;
  788.  
  789.   with Request^ do begin
  790.     Len    := SizeOf(TRequest) - 2;
  791.     SubF   := SubFChangeToServer;
  792.   end;
  793.   with NovRegs do begin
  794.     AH := BinderyFunc;
  795.     DS := SegOfs(S).Segm;
  796.     SI := 0;
  797.     ES := SegOfs(S).Segm;
  798.     DI := SizeOf(TRequest);
  799.     WinIntr($21, NovRegs);
  800.     RestoreQueueServerRights := AL;
  801.   end;
  802.   FreeRealModeMem(P);
  803. end;
  804.  
  805. function ServiceQueueJobAndOpenFile(QueueID : LongInt;
  806.                                     TargetJobType : Word;
  807.                                     var JobEntry : JobEntryType) : Byte;
  808. type
  809.   TRequest = record
  810.                Len    : Word;
  811.                SubF   : Byte;
  812.                QID    : LongInt;
  813.                JobT   : Word;
  814.              end;
  815.   TReply   = record
  816.                Len    : Word;
  817.                Entry  : JobEntryType;
  818.              end;
  819. var
  820.   Request    : ^TRequest;
  821.   Reply      : ^TReply;
  822.   NovRegs    : Registers;
  823.   S, P : Pointer;
  824. begin
  825.   ServiceQueueJobAndOpenFile := DPMIErrorVal;
  826.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  827.   Request := P;
  828.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  829.  
  830.   FillChar(Reply^,SizeOf(Reply^),0);
  831.   Reply^.Len := SizeOf(TReply) - 2;
  832.   with Request^ do begin
  833.     Len    := SizeOf(TRequest) - 2;
  834.     SubF   := SubFServiceJob;
  835.     QID    := NetWareSwapLong(QueueID);
  836.     JobT   := TargetJobType;
  837.   end;
  838.   with NovRegs do begin
  839.     AH := BinderyFunc;
  840.     DS := SegOfs(S).Segm;
  841.     SI := 0;
  842.     ES := SegOfs(S).Segm;
  843.     DI := SizeOf(TRequest);
  844.     WinIntr($21, NovRegs);
  845.     JobEntry := Reply^.Entry;
  846.     ServiceQueueJobAndOpenFile := AL;
  847.   end;
  848.   FreeRealModeMem(P);
  849. end;
  850.  
  851. function SetQueueCurrentStatus(QueueID : LongInt;
  852.                                QueueStatus : Byte) : Byte;
  853.  
  854. type
  855.   TRequest = record
  856.                Len    : Word;
  857.                SubF   : Byte;
  858.                QID    : LongInt;
  859.                QStat  : Byte;
  860.              end;
  861. var
  862.   Request    : ^TRequest;
  863.   Reply      : ^Word;
  864.   NovRegs    : Registers;
  865.   S, P : Pointer;
  866. begin
  867.   SetQueueCurrentStatus := DPMIErrorVal;
  868.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  869.   Request := P;
  870.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  871.   Reply^ := $0000;
  872.  
  873.   with Request^ do begin
  874.     Len    := SizeOf(TRequest) - 2;
  875.     SubF   := SubFReadQueStatus;
  876.     QID    := NetWareSwapLong(QueueID);
  877.     QStat  := QueueStatus;
  878.   end;
  879.   with NovRegs do begin
  880.     AH := BinderyFunc;
  881.     DS := SegOfs(S).Segm;
  882.     SI := 0;
  883.     ES := SegOfs(S).Segm;
  884.     DI := SizeOf(TRequest);
  885.     WinIntr($21, NovRegs);
  886.     SetQueueCurrentStatus := AL;
  887.   end;
  888.   FreeRealModeMem(P);
  889. end;
  890.  
  891. function SetQueueServerStatusRecord(QueueID : LongInt;
  892.                                     var StatusRec : ServerStatusRecord) : Byte;
  893.  
  894. type
  895.   TRequest = record
  896.                Len    : Word;
  897.                SubF   : Byte;
  898.                QID    : LongInt;
  899.                SRec   : ServerStatusRecord;
  900.              end;
  901. var
  902.   Request    : ^TRequest;
  903.   Reply      : ^Word;
  904.   NovRegs    : Registers;
  905.   S, P : Pointer;
  906. begin
  907.   SetQueueServerStatusRecord := DPMIErrorVal;
  908.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  909.   Request := P;
  910.   Reply := P;  Inc(Word(Reply), SizeOf(TRequest));
  911.   Reply^ := $0000;
  912.  
  913.   with Request^ do begin
  914.     Len    := SizeOf(TRequest) - 2;
  915.     SubF   := SubFSetStatusRec;
  916.     QID    := NetWareSwapLong(QueueID);
  917.     SRec   := StatusRec;
  918.   end;
  919.   with NovRegs do begin
  920.     AH := BinderyFunc;
  921.     DS := SegOfs(S).Segm;
  922.     SI := 0;
  923.     ES := SegOfs(S).Segm;
  924.     DI := SizeOf(TRequest);
  925.     WinIntr($21, NovRegs);
  926.     SetQueueServerStatusRecord := AL;
  927.   end;
  928.   FreeRealModeMem(P);
  929. end;
  930.  
  931. function JobSize(QueueID : LongInt; JobNumber : Word;
  932.                       var Size : LongInt) : Byte;
  933.   {-Returns the size of the data associate with queue QueueID and job
  934.     JobNumber}
  935. begin
  936.   JobSize := GetQueueJobFileSize(QueueID,JobNumber,Size);
  937.   Size := Size - SizeOf(JobEntryType);
  938. end;
  939.  
  940.